Lambda the Ultimate

Did anyone find an answer to the question asked in the 2/22/04 discussion, about whether there was any research on whether multilinguals learned programming language faster/more intuitively than monolinguals?

Oko is a development and data-management tool for creating Windows-based applications. It uses an object-oriented language similar to C++. A set of versatile visual-design tools makes it possible to create applications practically without programming. The environment includes data controls, as well as query and report designers... Get more info and download Oko at: http://ploko.net. We need testers.

Recently been looking at prototype-based languages eg. Self. While the concept sounds good, I've got this feeling that they are more memory intensive than class-based OOPLs. I haven't had the chance lately to check on this. Does anyone have experience or knowledge on this subject? Oh, and while I'm on this topic, how is the Prothon project getting on? I haven't been able to contact the site. Seems to be offline. Thanks.

Could it be that our gracious host has gone and got himself appointed to the Scheme Language Editors Committee?

I'd like to introduce an article which might be of some interest:

Reusing XML Processing Code in non-XML Applications

• HTML: http://uucode.com/texts/genxml/genxml.html
• PDF: http://uucode.com/texts/genxml/genxml.pdf

[abstract]

XML can be considered as a representation of hierarchical data, and the XML-related standards - as methods of processing such data. We describe benefits of XML view on legacy data and its processing, and suggest a method to develop XML tools and make them reusable for different tree-like structures in different programming languages.

Our approach is to use virtual machine technology, in particular, the Scheme programming language. We're taking the unusual step of using the Scheme syntax itself as a native virtual machine language. Together with the SXML format and Scheme implementations tuning, it gives us the XML virtual machine (XML VM).

Reference implementations are ready for the Python and C languages. We describe a library for XSLT-like transformations of the Python parse trees and a special version of the GNU find utility which supports XPath queries over the file system.

[/abstract]

The article needs some rework. Unfortunately, I don't know when I'll find time for it, so I publish it as is.

In the past few months, I've been studying programming languages/compilers/etc.. I'm surprised that basic data structures used to implement various language constructs are not given a great deal of importance.


Many PL/Compiler books mention tuples, records, trees, linked lists...but don't generally describe their performance trade-offs.


Simple matters such as using a basic linked list vs. a linked list which stores several keys in a node would greatly improve performance (and just one paper I've read mentions that most implementation do use such a technique).


Huge performance gains from languages such as fortran and APL seem to come from data locality as well (alhtough I can't be sure since I didn't get any straight answers from relevant usenet newgroups...or I didn't know how to phrase the question correctly).


Now I have collected enough books and papers which talk about lexing, parsing, type theory, functional vs. imperative, etc. But nothing which goes into detail about having the right set of fundamental data structures. For example: isn't it better to use to 'struct' to keep attributes of an object together in memory (since they are often likely to be used together), where as attributes of a large relation should be more liked a 'linked' data structure to allow quick addition/deletion of attributes (...basically adding relational algebra as a first class component my mini-language). What if I have a list of a million records (tuple with named attributes)...isn't it much better to have name/position correspondence stored on as part of list definition rather than a million times with each instance of record?


Data structures are, obviously, a seperate subject, but surely they deserve more attention in compiler/PL books. Any way, what do the experts on this forum think? Did I miss something obvious?

In light of yesterday's big news from Apple, I am left wondering what will become of the many fine language implementations that we have seen emerging under OS X?

Will the transition present problems for PLT Scheme, Haskell, Frontier, J, Croquet, FScript, etc....?

Will the various vm engines and self-hosted native code generation capabilities survive with a few minor tweaks and a simple recompile or are they predicated on the PowerPC architecture itself forcing language designers back to the blackboard?

Finally, from a purely technical perspective vis-a-vis the chip sets in question, was this move a stroke of genious, a case of 'worse is better', a bad idea, or an overall wash?

The Lambda calculus is a logical language and so are derivations such as lisp, scheme, and other functional languages. As such they theoretically could be used to prove facts as in languages like Prolog but I have never seen this done.

Moreover there is an intuitionistic logic (could this also be the more classic synthetic logic??) which could be quite useful for dealing with "real" dynamic, or uncertain environments. Something that could be very useful. Yet I am not awair of any practical tools for this.

Might not the logical interpretation of a function be more clear if the functions were written as rules, and had only a works/doesn't work return value?

Just wondering
Hank

I was wondering if there is any interest in a ranking of open source developers.

Such a ranking might be automatically determined by seeing how successful their applications have been (e.g., # downloads). We could also take into account other factors such as the size and complexity of the application.

Of course, if an application is built by many developers, we have to address the credit assignment problem. Namely, who is primarily responsible for the success of the application? We might examine the CVS repository to see who wrote what.

In any case, once we have this ranking of open source developers, we could then consider various applications:

* code search that returns code fragments written by particularly good developers (e.g., I might search for "drag and drop" across KDE apps and the most highly ranked drag & drop code fragments returned by the search would come from expert developers)

* mailing list search that takes into account how good of a developer the poster is (e.g., I might search for a problem related to drag and drop and the most highly ranked drag & drop messages returned by the search would come from expert developers)

Do you think building a ranking of open source developers would be worthwhile?

Do you think the applications mentioned would be compelling?

Evolving the Java Platform by Graham Hamilton:

Probably the most significant single feature in Mustang (J2SE 6.0) is the addition of a full-scale scripting engine, including a lightweight JavaScript implementation. We think the Java language is great, but we also think that scripting languages are a valuable adjunct to the core language.